export const uniqueId = (prefix = 'low') => {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
    const r = Math.random() * 16 | 0;
    const v = c === 'x' ? r : (r & 0x3 | 0x8);
    return v.toString(16);
  });
}
export const cloneDeep = (obj: any) => {
  return JSON.parse(JSON.stringify(obj))
}
export const updatePrimaryKey = (item) => {
  // item = cloneDeep(item)
  const jsonString = JSON.stringify(item, (key, value) => {
    if (key === '_id') {
        // 替换为随机字符串
        return uniqueId();
    }
    return value;
});

// 将修改后的 JSON 字符串解析回对象
return JSON.parse(jsonString);
  // if (item._id) {
  //   item._id = uniqueId();
  // }
  // // 如果对象是容器类型，递归更新其子项的 id
  // if (item.isContainer && item.properties && item.properties["x-component-props"] && item.properties["x-component-props"].items) {
  //   item.properties["x-component-props"].items.forEach(item => {
  //     updatePrimaryKey(item);
  //   });
  // }
  // return item
}
export function findWithRef(json:any,value:string) {
  // 如果当前节点是数组，递归遍历数组中的每个元素
  if (Array.isArray(json)) {
      for (let item of json) {
          const result = findWithRef(item,value);
          if (result) return result; // 如果找到，返回结果
      }
  } else if (typeof json === "object" && json !== null) {
      // 检查当前对象是否有 props 属性
      if (json.props && json.props.hasOwnProperty("$ref")&&json.$ref.value) {
          return json.props; // 返回包含 $ref 的 props 对象
      }
      // 如果当前对象没有 props 或 props 中没有 $ref，递归遍历它的 children 属性
      if (json.children) {
          return findWithRef(json.children,value); // 继续在 children 中查找
      }
  }
  // 如果遍历完都没有找到，返回 null
  return null;
}



export function moveItemDownById(data, idToMove) {
  // 遍历数组
  for (let i = 0; i < data.length; i++) {
    const item = data[i];
    
    // 如果找到匹配的 id
    if (item._id === idToMove) {
      // 如果是最后一个元素，无法向下移动
      if (i === data.length - 1) {
        return false;
      }
      
      // 与后一个元素交换位置
      [data[i], data[i + 1]] = [data[i + 1], data[i]];
      return true; // 返回 true 表示移动成功
    }
    
    // 如果对象是容器类型，递归检查其子项
    if (item.children) {
      const moved = moveItemDownById(item.children, idToMove);
      if (moved) {
        return true; // 子项中移动成功
      }
    }
  }
  
  return false; // 未找到匹配的 id 或无法移动
}
export function moveItemUpById(data, idToMove) {
  // 遍历数组
  for (let i = 0; i < data.length; i++) {
    const item = data[i];
    
    // 如果找到匹配的 id
    if (item._id === idToMove) {
      // 如果是第一个元素，无法向上移动
      if (i === 0) {
        return false;
      }
      
      // 与前一个元素交换位置
      [data[i], data[i - 1]] = [data[i - 1], data[i]];
      return true; // 返回 true 表示移动成功
    }
    
    // 如果对象是容器类型，递归检查其子项
    if (item.children) {
      const moved = moveItemUpById(item.children, idToMove);
      if (moved) {
        return true; // 子项中移动成功
      }
    }
  }
  
  return false; // 未找到匹配的 id 或无法移动
}

// export const findParentSchema = (schema,_id:string)=>{
//    for(let i=0;i<schema.length;i++){
//        let parentSchema = schema[i];
//        if(parentSchema._id==_id){
//         return parentSchema
//        }
//        if(parentSchema.isContainer){

//        }
//    }

// }

export function findItemById(items, id) {
  for (let item of items) {
    if (item._id === id) {
      return item;
    }
    if (item.children ) {
      const foundItem = findItemById(item.children, id);
      if (foundItem) {
        return foundItem;
      }
    }
  }
  return null;
}
export function removeItemById(items, idToRemove) {
  // 遍历数组
  for (let i = 0; i < items.length; i++) {
    const item = items[i];

    // 如果找到匹配的 id，从数组中删除该对象
    if (item._id === idToRemove) {
      items.splice(i, 1);
      return true; // 返回 true 表示删除成功
    }

    // 如果对象是容器类型，递归检查其子项
    if (item.children) {
      const removed = removeItemById(item.children, idToRemove);
      if (removed) {
        return true; // 子项中删除成功
      }
    }
  }

  return false; // 未找到匹配的 id
}


export function copyAndAddItemById(data, idToCopy) {
  
  // 遍历数组
  for (let i = 0; i < data.length; i++) {
    const item = data[i];

    // 如果找到匹配的 id，复制该对象
    if (item._id === idToCopy) {
      // 深拷贝对象
      let copiedItem = updatePrimaryKey(cloneDeep(item));



      // 添加到原数组
      data.push(copiedItem);
      return true; // 返回 true 表示操作成功
    }

    // 如果对象是容器类型，递归检查其子项
    if (item.children) {
      const added = copyAndAddItemById(item.children, idToCopy);
      if (added) {
        return true; // 子项中操作成功
      }
    }
  }

  return false; // 未找到匹配的 id
}

export function findContainerById(items, id) {
  if (!id) {
    return null
  }
  const item = findItemById(items, id);
  if (!item) {
    return null
  }
  if (item.isContainer) {
    return item;
  }
  // 如果当前项不是容器，向上查找父容器
  return findParentContainer(items, item);
}
 export function findParent(jsonArray, targetId) {
  // 定义一个递归函数，用于遍历 JSON 数组
  function recursiveSearch(array, parentObject) {
    for (let item of array) {
      // 如果当前项的_id等于目标_id，返回其父级对象
      if (item._id === targetId) {
        return parentObject;
      }
      // 如果当前项有子数组，继续递归搜索
      if (item.children && Array.isArray(item.children)) {
        const parent = recursiveSearch(item.children, item);
        if (parent !== null) {
          return parent;
        }
      }
    }
    // 如果没有找到目标_id，返回null
    return null;
  }

  // 从根级开始搜索，根级没有父级，所以传入null
  return recursiveSearch(jsonArray, null);
}
function findParentContainer(items, item) {
  for (let parent of items) {
    if (parent.properties && parent.properties['x-component-props'] && parent.properties['x-component-props'].items) {
      for (let child of parent.properties['x-component-props'].items) {
        if (child === item) {
          return parent;
        }
        const parentContainer = findParentContainer(parent.properties['x-component-props'].items, item);
        if (parentContainer) {
          return parentContainer;
        }
      }
    }
  }
  return null;
}